/**
 * Copyright (c) 2015-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * 
 * @format
 */

'use strict';

const AssetPaths = require('./lib/AssetPaths');
const MapWithDefaults = require('./lib/MapWithDefaults');

























const EMPTY_ARRAY = [];

/**
                         * Lazily build an index of assets for the directories in which we're looking
                         * for specific assets. For example if we're looking for `foo.png` in a `bar`
                         * directory, we'll look at all the files there and identify all the assets
                         * related to `foo.png`, for example `foo@2x.png` and `foo.ios.png`.
                         */
class AssetResolutionCache {



  constructor(options) {this.








































    _findAssets = dirPath => {
      const results = new Map();
      const fileNames = this._opts.getDirFiles(dirPath);
      for (let i = 0; i < fileNames.length; ++i) {
        const fileName = fileNames[i];
        const assetData = AssetPaths.tryParse(fileName, this._opts.platforms);
        if (assetData == null || !this._isValidAsset(assetData)) {
          continue;
        }
        getWithDefaultArray(results, assetData.assetName).push({
          fileName,
          platform: assetData.platform });

        if (assetData.platform) {
          const assetNameWithPlatform = `${assetData.name}.${assetData.platform}.${assetData.type}`;
          getWithDefaultArray(results, assetNameWithPlatform).push({
            fileName,
            platform: null });

        }
      }
      return results;
    };this._assetsByDirPath = new MapWithDefaults(this._findAssets);this._opts = options;} /**
                                                                                            * The cache needs to be emptied if any file changes. This could be made more
                                                                                            * selective if performance demands it: for example, we could clear
                                                                                            * exclusively the directories in which files have changed. But that'd be
                                                                                            * more error-prone.
                                                                                            */clear() {this._assetsByDirPath.clear();} /**
                                                                                                                                        * Get the file paths of all the variants (resolutions, platforms, etc.) of a
                                                                                                                                        * particular asset name, only looking at a specific directory. If needed this
                                                                                                                                        * function could be changed to return pre-parsed information about the assets
                                                                                                                                        * such as the resolution.
                                                                                                                                        */resolve(dirPath, assetName, platform) {const results = this._assetsByDirPath.get(dirPath);const assets = results.get(assetName);if (assets == null) {return EMPTY_ARRAY;}return assets.filter(asset => asset.platform == null || asset.platform === platform).map(asset => asset.fileName);} /**
                                                                                                                                                                                                                                                                                                                                                                                                                                        * Build an index of assets for a particular directory. Several file can
                                                                                                                                                                                                                                                                                                                                                                                                                                        * fulfill a single asset name, for example the different resolutions or
                                                                                                                                                                                                                                                                                                                                                                                                                                        * platforms: ex. `foo.png` could contain `foo@2x.png`, `foo.ios.js`, etc.
                                                                                                                                                                                                                                                                                                                                                                                                                                        */_isValidAsset(assetData) {return this._opts.assetExtensions.has(assetData.type);}} /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Used instead of `MapWithDefaults` so that we don't create empty arrays
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * anymore once the index is built.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */function getWithDefaultArray(map, key) {let el = map.get(key);if (el != null) {return el;
  }
  el = [];
  map.set(key, el);
  return el;
}

module.exports = AssetResolutionCache;